const { Controller } = require('egg'); 

class ResumeController extends Controller {
    // 创建简历（仅支持文件URL，移除title和content相关逻辑）
    async create() {
        const { ctx, service } = this;
        try {
            // 参数验证：仅校验file_url和visibility（必传file_url）
            const rules = {
                file_url: { type: 'string', required: true }, // 强制必填
                visibility: { type: 'number', required: false, defValue: 0 } // 默认0（与模型一致）
            };
            ctx.validate(rules);

            const resumeData = ctx.request.body;
            const result = await service.resume.create(resumeData);

            ctx.body = { code: 0, data: result, msg: '简历上传成功' };
        } catch (error) {
            ctx.body = {
                code: 1,
                data: null,
                msg: error.errors ? `参数错误: ${error.errors[0].field} ${error.errors[0].message}` : error.message || '上传失败'
            };
        }
    }

    // 获取当前用户的简历列表（返回字段自动适配模型）
    async myResumes() {
        const { ctx, service } = this;
        try {
            const userId = ctx.state.user_id;
            if (!userId) { ctx.body = { code: 1, msg: '请先登录' }; return; }

            const result = await service.resume.getUserResumes(userId, ctx.query);
            ctx.body = { code: 0, data: result, msg: '获取列表成功' };
        } catch (error) {
            ctx.body = { code: 1, data: null, msg: error.message || '获取失败' };
        }
    }

    // 更新简历（仅允许更新file_url和visibility）
    async update() {
        const { ctx, service } = this;
        try {
            const { id } = ctx.params;
            const updateData = ctx.request.body;

            // 参数验证：仅允许更新file_url和visibility
            const paramRules = { id: { type: 'id', required: true } };
            const bodyRules = {
                file_url: { type: 'string', required: false },
                visibility: { type: 'number', required: false }
            };
            ctx.validate(paramRules, ctx.params);
            ctx.validate(bodyRules);

            const result = await service.resume.update(id, updateData);
            ctx.body = { code: 0, data: result, msg: '更新成功' };
        } catch (error) {
            ctx.body = {
                code: 1,
                data: null,
                msg: error.errors ? `参数错误: ${error.errors[0].field} ${error.errors[0].message}` : error.message || '更新失败'
            };
        }
    }

    // 其他方法（show、setVisibility、destroy）逻辑不变，无需调整
    async show() {
        const { ctx, service } = this;
        try {
            const { id } = ctx.params;
            ctx.validate({ id: { type: 'id', required: true } }, ctx.params);

            const resume = await service.resume.getResumeById(id);
            ctx.body = { code: 0, data: resume, msg: '获取详情成功' };
        } catch (error) {
            ctx.body = {
                code: 1,
                data: null,
                msg: error.errors ? `参数错误: ${error.errors[0].field} ${error.errors[0].message}` : error.message || '获取失败'
            };
        }
    }

    async setVisibility() {
        const { ctx, service } = this;
        try {
            const { id } = ctx.params;
            const { visibility } = ctx.request.body;

            ctx.validate({ id: { type: 'id', required: true } }, ctx.params);
            ctx.validate({ visibility: { type: 'number', required: true } });

            const result = await service.resume.updateVisibility(id, visibility);
            ctx.body = { code: 0, data: result, msg: '设置可见性成功' };
        } catch (error) {
            ctx.body = {
                code: 1,
                data: null,
                msg: error.errors ? `参数错误: ${error.errors[0].field} ${error.errors[0].message}` : error.message || '设置失败'
            };
        }
    }

    async destroy() {
        const { ctx, service } = this;
        try {
            const { id } = ctx.params;
            ctx.validate({ id: { type: 'id', required: true } }, ctx.params);

            await service.resume.delete(id);
            ctx.body = { code: 0, data: null, msg: '删除成功' };
        } catch (error) {
            ctx.body = {
                code: 1,
                data: null,
                msg: error.errors ? `参数错误: ${error.errors[0].field} ${error.errors[0].message}` : error.message || '删除失败'
            };
        }
    }
    // 新增：获取指定用户的公开简历列表（visibility=1）
    async userPublicResumes() {
        const { ctx, service } = this;
        try {
            const { user_id } = ctx.params;
            // 验证用户ID参数
            ctx.validate({ user_id: { type: 'id', required: true } }, ctx.params);

            const result = await service.resume.getUserPublicResumes(user_id, ctx.query);
            ctx.body = { code: 0, data: result, msg: '获取公开简历列表成功' };
        } catch (error) {
            ctx.body = {
                code: 1,
                data: null,
                msg: error.errors ? `参数错误: ${error.errors[0].field} ${error.errors[0].message}` : error.message || '获取失败'
            };
        }
    }
    // 在 ResumeController 类中添加以下方法
async uploadResumeImage() {
  const { ctx, service } = this;

  try {
    console.log('收到简历图片上传请求');

    // 验证token（修正获取方式）
    const authorization = ctx.request.header.authorization; // 从Authorization头获取
    if (!authorization) {
      throw new Error('未提供token');
    }
    // 提取Bearer后的token（格式：Bearer <token>）
    const token = authorization.split(' ')[1];
    if (!token) {
      throw new Error('token格式错误（应为Bearer Token）');
    }

    // 验证token
    const decode = ctx.app.jwt.verify(token, ctx.app.config.jwt.secret);
    const userId = decode.user_id;

        console.log('用户ID:', userId);

        // 获取上传的文件
        const file = ctx.request.files[0];
        if (!file) {
            throw new Error('请选择要上传的简历图片');
        }

        console.log('上传文件信息:', {
            filename: file.filename,
            filepath: file.filepath,
            mimeType: file.mimeType,
            size: file.size
        });

        // 验证文件类型
        const allowedTypes = ['image/jpeg', 'image/png', 'image/gif', 'image/webp', 'application/pdf'];
        if (!allowedTypes.includes(file.mimeType)) {
            throw new Error('只支持 jpg、png、gif、webp、pdf 格式的文件');
        }

        // 验证文件大小（限制为10MB）
        const maxSize = 10 * 1024 * 1024;
        if (file.size > maxSize) {
            throw new Error('文件大小不能超过10MB');
        }

        // 上传简历图片
        const imageUrl = await service.upload.uploadResumeImage(file, userId);
        console.log('新简历图片URL:', imageUrl);

        ctx.body = {
            code: 0,
            data: {
                url: imageUrl
            },
            msg: '简历图片上传成功'
        };

        console.log('简历图片上传完成');

    } catch (error) {
        console.error('简历图片上传错误:', error);

        // 清理临时文件
        if (ctx.request.files) {
            ctx.cleanupRequestFiles();
        }

        if (error.errors) {
            ctx.body = {
                code: 1,
                data: null,
                msg: `参数错误: ${error.errors[0].field} ${error.errors[0].message}`
            };
            return;
        }

        ctx.body = {
            code: 1,
            data: null,
            msg: error.message || '简历图片上传失败'
        };
    }
}
}

module.exports = ResumeController;